RIOT OS Paves the Way for Implementation of High-Performance MAC Protocols

Implementing new, high-performance MAC protocols requires real-time features, to be able to synchronize correctly between different unrelated devices. Such features are highly desirable for operating wireless sensor networks (WSN) that are designed to be part of the Internet of Things (IoT). Unfortunately, the operating systems commonly used in this domain cannot provide such features. On the other hand, "bare-metal" development sacrifices portability, as well as the mul-titasking abilities needed to develop the rich applications that are useful in the domain of the Internet of Things. We describe in this paper how we helped solving these issues by contributing to the development of a port of RIOT OS on the MSP430 microcontroller, an architecture widely used in IoT-enabled motes. RIOT OS offers rich and advanced real-time features, especially the simultaneous use of as many hardware timers as the underlying platform (microcontroller) can offer. We then demonstrate the effectiveness of these features by presenting a new implementation, on RIOT OS, of S-CoSenS, an efficient MAC protocol that uses very low processing power and energy.Comment: SCITEPRESS. SENSORNETS 2015, Feb 2015, Angers, France. http://www.scitepress.or

Memory and compiler optimizations for low-power and -energy.

ICOOOLPS'2006 was co-located with the 20th European Conference on Object-Oriented Programming (ECOOP'2006).International audienceEmbedded systems become more and more widespread, especially autonomous ones, and clearly tend to be ubiquitous. In such systems, low-power and low-energy usage get ever more crucial. Furthermore, these issues also become paramount in (massively) multi-processors systems, either in one machine or more widely in a grid. The various problems faced pertain to autonomy, power supply possibilities, thermal dissipation, or even sheer energy cost. Although it has since long been studied in harware, energy optimization is more recent in software. In this paper, we thus aim at raising awareness to low-power and low-energy issues in the language and compilation community. We thus broadly but briefly survey techniques and solutions to this energy issue, focusing on a few specific aspects in the context of compiler optimizations and memory management

Compilation et faible consommation

Chronique. Parution initialement prévue en 2006-2007, puis repoussée à 2008... Modifications à faire.Résumé : In autonomous embedded systems --- which become more and more present in our daily life --- energy management is a crucial issue. Although it has been widely studied from a hardware point of view, this domain remains less explored in software, especially with respect to compiler support where historically optimizations generally dealt with speed. This paper thus aims at providing a survey of low-power and low-energy compilation techniques. It briefly introduces low-level techniques, theNational audienceIn autonomous embedded systems --- which become more and more present in our daily life --- energy management is a crucial issue. Although it has been widely studied from a hardware point of view, this domain remains less explored in software, especially with respect to compiler support where historically optimizations generally dealt with speed. This paper thus aims at providing a survey of low-power and low-energy compilation techniques. It briefly introduces low-level techniques, then presents more largely higher-level techniques, especially those pertaining to memory management and operation modes of resources, before drawing the domain perspectives

Adding external iterators to an existing Eiffel class library

Colloque avec actes et comité de lecture./http://ieeexplore.ieee.org/This paper discusses common iteration schemes and highlights the interest of using explicit iterators. The advantages of external iterators are compared to those of internalized iterators. The integration of an iterator class hierarchy to an existing library without modifying the latter is detailed. This integration brings an extra level of abstraction to the library, which thus becomes more flexible, more adapted to certain design patterns and hence can be used in a higher-level way. Such an integration is not only possible, but can even be done in an optimized way, taking into account the specific structure of the collection traversed. A slight extension of existing class libraries can also be implemented that does not cause any compatibility problem and does not break existing code, but allows even further abstraction and makes it easier for the developer to use high-level, optimized, external iterators

Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems - Report on the Workshop ICOOOLPS'2006 at ECOOP'06

ICOOOLPS'2006 was the first edition of ECOOP-ICOOOLPS workshop. It intended to bring researchers and practitioners both from academia and industry together, with a spirit of openness, to try and identify and begin to address the numerous and very varied issues of optimization. This succeeded, as can be seen from the papers, the attendance and the liveliness of the discussions that took place during and after the workshop, not to mention a few new cooperations or postdoctoral contracts. The 22 talented people from different groups who participated were unanimous to appreciate this first edition and recommend that ICOOOLPS be continued next year. A community is thus beginning to form, and should be reinforced by a second edition next year, with all the improvements this first edition made emerge.Comment: The original publication is available at http://www.springerlink.co

Open-PEOPLE : Ergonomics

Our software platform is composed of several tools implemented as a set of Eclipse plugins using the Eclipse RCP standard "extension point" mechanism. This is the lightweight software integration model we decided to use during the conception of the OPSWP (see deliverable D2.2 for details), whose graphical consistency is guaranteed a minima thanks to the basic UI mechanisms (SWT widgets, workspace, etc.) of the Eclipse RCP. Each one of the integrated software tools is part of the model-driven workflow used by our platform to implement its features; however, these tools are not basically conceived to work together, thus undermining the coherency and usability of the OPSWP. Since the usability of our future software platform is a major concern for us, we are putting much effort into the harmonization of the various software elements to offer the best possible user experience to the system architects who will be our main users. The purpose of this document is to describe how we intend to provide good ergonomics to the OPSWP: we will especially explain the choices we made about the GUI conception. Ergonomics are only a question of usability, which depends on the good organization of GUI, on good use of visual components, forms, and so on. Ergonomics don't define neither the graphic charter nor the visual identity of our software: these "artistic" considerations are part of the project's task 6 (dissemination). The present study is divided into several consecutive parts: we first begin by analyzing user profiles and their related tasks, then we review the technical and architectural constraints that are imposed to us. From all of these, we eventually build a style guide, that defines the usability requirements that shall be followed as guidelines to implement the graphical user interfaces (GUIs) of the OPSWP software elements with the expected consistency. This document - not planned at the beginning - is part of task 2 of the OP project. This task is under the responsibility of the INRIA NGE team, and its main goal is the specification, conception and implementation of the OPSWP

Optimized late binding: the SmallEiffel example

International audiencePoster showing late binding mecanisms as implemented in the SmallEiffel compiler

Visualization of the Static aspects of Software: a survey

International audienceSoftware is usually complex and always intangible. In practice, the development and maintenance processes are time-consuming activities mainly because software complexity is difficult to manage. Graphical visualization of software has the potential to result in a better and faster understanding of its design and functionality, saving time and providing valuable information to improve its quality. However, visualizing software is not an easy task because of the huge amount of information comprised in the software. Furthermore, the information content increases significantly once the time dimension to visualize the evolution of the software is taken into account. Human perception of information and cognitive factors must thus be taken into account to improve the understandability of the visualization. In this paper, we survey visualization techniques, both 2D- and 3D-based, representing the static aspects of the software and its evolution. We categorize these techniques according to the issues they focus on, in order to help compare them and identify the most relevant techniques and tools for a given problem

Optimizations of Eiffel programs: SmallEiffel, The GNU Eiffel Compiler.

Colloque avec actes et comité de lecture./http://csdl2.computer.org/The design of the Eiffel language makes it possible to perform global optimizations on Eiffel programs. In this paper, we describe some of the techniques we used in SmallEiffel, The GNU Eiffel Compiler, to generate highly efficient executables for Eiffel programs. Most of these techniques --- related to global analysis or not --- may also be applied to other object-oriented languages

Vers un usage plus sûr de l'aliasing avec Eiffel

Colloque avec actes et comité de lecture. nationale./http://www.hermes-science.comNational audienceLe code source du compilateur SmallEiffel fait un usage intensif de l'aliasing afin d'atteindre les meilleures performances, tant en termes de mémoire que de vitesse d'exécution. Cette technique semble très appropriée à la compilation mais peut aussi s'appliquer à une large gamme d'applications. Grâce aux capacités de programmation par contrat du langage Eiffel, l'aliasing peut être géré d'une façon assez sûre. Le modèle de conception singleton se révèle également crucial pour l'implantation d'objets fournisseurs d'alias. Nous présentons ici une implantation efficace de ce modèle rendue possible par certains idiomes d'Eiffel